const express = require('express');
const router = express.Router();
const { Printer, Task, File } = require('../models');
const net = require('net');
const http = require('http');

const PrintService = require('../services/printService');


const sequelize = require('../config/database');

// 获取系统打印机列表
router.get('/system', async (req, res) => {
  try {
    console.log('获取系统打印机列表...');
    const printers = await PrintService.getSystemPrinters();
    res.json(printers);
  } catch (error) {
    console.error('获取系统打印机列表失败:', error);
    res.status(500).json({ message: error.message });
  }
});

// 获取所有打印机
router.get('/', async (req, res) => {
  try {
    const printers = await Printer.findAll();
    res.json({ printers });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

// 统一获取所有打印机（包括系统和网络打印机）
router.get('/all', async (req, res) => {
  try {
    console.log('获取所有系统和网络打印机...');
    const allPrinters = await PrintService.getAllPrinters();
    res.json({ 
      printers: allPrinters,
      count: allPrinters.length,
      timestamp: new Date().toISOString()
    });
  } catch (error) {
    console.error('获取所有打印机失败:', error);
    res.status(500).json({ 
      message: error.message,
      success: false
    });
  }
});

// 获取单个打印机
router.get('/:id', async (req, res) => {
  try {
    const printer = await Printer.findByPk(req.params.id);
    if (!printer) {
      return res.status(404).json({ message: '打印机不存在' });
    }
    res.json(printer);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

// 创建新打印机
router.post('/', async (req, res) => {
  try {
    const printer = await Printer.create(req.body);
    res.status(201).json(printer);
  } catch (error) {
    res.status(400).json({ message: error.message });
  }
});

// 更新打印机
router.put('/:id', async (req, res) => {
  try {
    const printer = await Printer.findByPk(req.params.id);
    if (!printer) {
      return res.status(404).json({ message: '打印机不存在' });
    }
    await printer.update(req.body);
    res.json(printer);
  } catch (error) {
    res.status(400).json({ message: error.message });
  }
});

// 删除打印机
router.delete('/:id', async (req, res) => {
  const transaction = await sequelize.transaction();
  
  try {
    console.log(`尝试删除打印机ID: ${req.params.id}`);
    
    // 首先检查打印机是否存在
    const printer = await Printer.findByPk(req.params.id, { transaction });
    if (!printer) {
      await transaction.rollback();
      return res.status(404).json({ 
        message: '打印机不存在',
        success: false 
      });
    }
    
    // 查找与该打印机关联的任务
    const relatedTasks = await Task.findAll({
      where: { printerId: req.params.id },
      transaction
    });
    
    // 如果有关联任务，先删除这些任务
    if (relatedTasks.length > 0) {
      console.log(`删除打印机前先删除${relatedTasks.length}个关联任务...`);
      for (const task of relatedTasks) {
        await task.destroy({ transaction });
      }
    }
    
    // 删除打印机
    await printer.destroy({ transaction });
    
    // 提交事务
    await transaction.commit();
    
    console.log(`打印机ID ${req.params.id} 已成功删除`);
    res.json({ 
      message: '打印机已删除',
      success: true 
    });
  } catch (error) {
    // 回滚事务
    await transaction.rollback();
    
    console.error('删除打印机失败:', error);
    res.status(500).json({ 
      message: `删除打印机失败: ${error.message}`,
      success: false,
      error: error.message
    });
  }
});

// 扫描打印机
router.post('/scan', async (req, res) => {
  const { startIP, endIP } = req.body;
  const foundPrinters = [];
  console.log('开始扫描')
  try {
    // 解析IP地址
    const startParts = startIP.split('.').map(Number);
    const endParts = endIP.split('.').map(Number);
    
    // 生成IP范围
    const start = startParts[3];
    const end = endParts[3];
    
    for (let i = start; i <= end; i++) {
      const ip = `${startParts[0]}.${startParts[1]}.${startParts[2]}.${i}`;
      console.log('正在连接ip', ip)
      try {
        // 尝试连接IPP端口(631)
        const ippUrl = `http://${ip}:631/ipp/print`;
        
        await new Promise((resolve, reject) => {
          const req = http.get(ippUrl, (res) => {
            if (res.statusCode === 200 || res.statusCode === 401) {
              resolve();
            } else {
              reject(new Error(`Status code: ${res.statusCode}`));
            }
          });
          
          req.on('error', (err) => {
            reject(err);
          });
          
          req.setTimeout(1000, () => {
            req.destroy();
            reject(new Error('timeout'));
          });
        });
        
        // 如果连接成功，说明是IPP打印机
        foundPrinters.push({
          name: `IPP打印机 ${ip}`,
          ip: ip,
          port: 631,
          enableColor: true,
          description: '自动扫描发现的IPP打印机',
          isOnline: true,
          taskCount: 0,
          lastOnline: new Date(),
          todayPrintCount: 0,
          failedPrintCount: 0,
          protocol: 'IPP'
        });
      } catch (err) {
        // 如果不是IPP打印机，尝试连接标准打印机端口(9100)
        try {
          const socket = new net.Socket();
          const timeout = 1000; // 1秒超时
          
          await new Promise((resolve, reject) => {
            socket.setTimeout(timeout);
            
            socket.on('connect', () => {
              socket.destroy();
              resolve();
            });
            
            socket.on('timeout', () => {
              socket.destroy();
              reject(new Error('timeout'));
            });
            
            socket.on('error', (err) => {
              reject(err);
            });
            
            socket.connect(9100, ip);
          });
          
          // 如果连接成功，说明是标准网络打印机
          foundPrinters.push({
            name: `打印机 ${ip}`,
            ip: ip,
            port: 9100,
            enableColor: true,
            description: '自动扫描发现的打印机',
            isOnline: true,
            taskCount: 0,
            lastOnline: new Date(),
            todayPrintCount: 0,
            failedPrintCount: 0,
            protocol: 'RAW'
          });
        } catch (err) {
          // 连接失败，继续下一个IP
          continue;
        }
      }
    }
    
    // 批量创建或更新打印机
    for (const printer of foundPrinters) {
      await Printer.upsert(printer, {
        where: { ip: printer.ip }
      });
    }
    
    res.json({
      message: '扫描完成',
      count: foundPrinters.length,
      printers: foundPrinters
    });
  } catch (error) {
    console.error('扫描打印机失败:', error);
    res.status(500).json({ error: '扫描打印机失败' });
  }
});

// 获取打印机任务列表
router.get('/:id/tasks', async (req, res) => {
  try {
    const tasks = await Task.findAll({
      where: { printerId: req.params.id },
      include: [{ model: File, required: false }],
      order: [['createdAt', 'DESC']]
    });

    const formattedTasks = tasks.map(task => {
      const base = {
        id: task.id.toString(),
        status: task.status,
        createdAt: task.createdAt,
        copies: task.copies,
        color: task.color,
        colorMode: task.colorMode || 'monochrome',
        quality: task.quality || 'normal',
        format: task.format || 'application/octet-stream',
        duplex: task.duplex,
        printerId: task.printerId,
        fileId: task.fileId
      };

      // 如果有关联的文件，则添加文件信息
      if (task.File) {
        return {
          ...base,
          name: task.File.name,
          originalName: task.File.originalName,
          size: task.File.size,
          type: task.File.type
        };
      } else {
        // 如果没有关联的文件，使用默认值
        return {
          ...base,
          name: '未知文件',
          originalName: '未知文件',
          size: 0,
          type: ''
        };
      }
    });

    res.json(formattedTasks);
  } catch (error) {
    console.error('获取任务列表失败:', error);
    res.status(500).json({ message: '获取任务列表失败' });
  }
});

// 开始打印任务
router.post('/:printerId/tasks/:taskId/start', async (req, res) => {
  try {
    // 检查打印机是否存在和在线
    const printer = await Printer.findByPk(req.params.printerId);
    if (!printer) {
      return res.status(404).json({ error: '打印机不存在' });
    }
    if (!printer.isOnline) {
      return res.status(400).json({ error: '打印机离线，请检查打印机状态' });
    }

    const task = await Task.findByPk(req.params.taskId, {
      include: [{ model: File }]
    });

    if (!task) {
      return res.status(404).json({ error: '任务不存在' });
    }

    if (!task.File) {
      return res.status(404).json({ error: '文件不存在' });
    }

    const { copies, color, duplex } = req.body;

    // 更新任务状态和打印设置
    await task.update({
      status: 'printing',
      copies: copies || task.copies,
      color: color !== undefined ? color : task.color,
      duplex: duplex !== undefined ? duplex : task.duplex
    });

    // 更新打印机统计信息
    await printer.increment('taskCount');
    await printer.increment('todayPrintCount');

    // 异步执行打印任务
    PrintService.printDocument(task.id).catch(error => {
      console.error('打印执行失败:', error);
      // 如果打印失败，更新任务状态
      task.update({
        status: 'failed',
        errorMessage: error.message
      }).catch(err => {
        console.error('更新任务状态失败:', err);
      });
    });

    // 返回更新后的任务信息
    res.json({
      id: task.id.toString(),
      name: task.File.name,
      originalName: task.File.originalName,
      status: task.status,
      createdAt: task.createdAt,
      copies: task.copies,
      color: task.color,
      duplex: task.duplex,
      printerId: task.printerId,
      size: task.File.size,
      type: task.File.type
    });
  } catch (error) {
    console.error('开始打印失败:', error);
    res.status(500).json({ error: '开始打印失败，请重试' });
  }
});

// 获取打印机的文件列表
router.get('/:id/files', async (req, res) => {
  try {
    // 获取该打印机的所有任务
    const tasks = await Task.findAll({
      where: { printerId: req.params.id },
      attributes: ['fileId']
    });

    // 获取所有相关的文件ID
    const fileIds = tasks.map(task => task.fileId);

    // 从文件表中获取所有文件
    const files = await File.findAll({
      where: { id: fileIds },
      order: [['createdAt', 'DESC']]
    });

    // 格式化文件信息
    const formattedFiles = files.map(file => ({
      id: file.id,
      name: file.name,
      originalName: file.originalName,
      size: file.size,
      type: file.type,
      createdAt: file.createdAt
    }));

    res.json(formattedFiles);
  } catch (error) {
    console.error('获取打印机文件列表失败:', error);
    res.status(500).json({ error: '获取文件列表失败' });
  }
});

// 创建打印任务
router.post('/:id/tasks', async (req, res) => {
  try {
    const { id } = req.params;
    const { fileId, copies, color, colorMode, quality, format } = req.body;

    // 获取打印机和文件信息
    const printer = await Printer.findByPk(id);
    if (!printer) {
      return res.status(404).json({ message: '打印机不存在' });
    }

    const file = await File.findByPk(fileId);
    if (!file) {
      return res.status(404).json({ message: '文件不存在' });
    }

    // 创建打印任务
    const task = await Task.create({
      fileId,
      printerId: id,
      status: 'pending',
      copies: copies || 1,
      color: color || false,
      colorMode: colorMode || 'monochrome',
      quality: quality || 'normal',
      format: format || 'application/octet-stream'
    });

    res.json(task);
  } catch (error) {
    console.error('创建打印任务失败:', error);
    res.status(500).json({ message: '创建打印任务失败' });
  }
});

// 执行打印任务
router.post('/:id/tasks/:taskId/print', async (req, res) => {
  try {
    const { id, taskId } = req.params;
    
    // 获取打印机、任务和文件信息
    const printer = await Printer.findByPk(id);
    if (!printer) {
      return res.status(404).json({ message: '打印机不存在' });
    }

    const task = await Task.findByPk(taskId);
    if (!task) {
      return res.status(404).json({ message: '任务不存在' });
    }

    const file = await File.findByPk(task.fileId);
    if (!file) {
      return res.status(404).json({ message: '文件不存在' });
    }

    // 将任务状态更新为打印中
    await task.update({ status: 'printing' });

    // 异步执行打印
    PrintService.printDocument(printer, file, task).then(async () => {
      // 打印成功，更新打印机统计
      await printer.increment('taskCount');
      await printer.increment('todayPrintCount');
    }).catch(async (error) => {
      console.error('打印任务执行失败:', error);
      await printer.increment('failedPrintCount');
    });

    res.json({ message: '打印任务已开始执行' });
  } catch (error) {
    console.error('执行打印失败:', error);
    res.status(500).json({ message: '执行打印失败' });
  }
});

// 删除打印任务
router.delete('/:printerId/tasks/:taskId', async (req, res) => {
  try {
    const task = await Task.findByPk(req.params.taskId);

    if (!task) {
      return res.status(404).json({ error: '任务不存在' });
    }

    // 只删除任务记录
    await task.destroy();

    res.status(200).json({ message: '删除成功' });
  } catch (error) {
    console.error('删除任务失败:', error);
    res.status(500).json({ error: '删除任务失败，请重试' });
  }
});

// 同步系统打印机到数据库
router.post('/sync', async (req, res) => {
  let transaction;
  try {
    console.log('开始同步系统打印机到数据库...');
    
    // 获取系统打印机列表
    const systemPrinters = await PrintService.getSystemPrinters();
    console.log(`找到 ${systemPrinters.length} 台系统打印机`);
    
    // 使用原始SQL语句关闭外键检查并清空相关表
    console.log('使用SQL操作处理数据...');
    transaction = await sequelize.transaction();
    
    // 关闭外键检查
    await sequelize.query('PRAGMA foreign_keys = OFF;', { transaction });
    
    // 检查是否存在isSystemPrinter字段，不存在则添加
    console.log('检查数据库字段...');
    const tableInfo = await sequelize.query(
      "PRAGMA table_info('Printers')",
      { type: sequelize.QueryTypes.SELECT, transaction }
    );
    console.log('Printers表字段:', tableInfo.map(col => col.name));
    
    // 提取表中存在的列名
    const existingColumns = tableInfo.map(col => col.name);
    
    // 如果不存在isSystemPrinter字段，添加它
    if (!existingColumns.includes('isSystemPrinter')) {
      console.log('添加缺失的isSystemPrinter字段...');
      await sequelize.query(
        "ALTER TABLE Printers ADD COLUMN isSystemPrinter BOOLEAN DEFAULT 0 NOT NULL",
        { transaction }
      );
      console.log('成功添加isSystemPrinter字段');
    }
    
    // 首先删除所有系统打印机
    console.log('删除现有系统打印机...');
    await sequelize.query('DELETE FROM Printers WHERE isSystemPrinter = 1;', { transaction });
    
    // 查询当前表结构（可能已更新）
    const updatedTableInfo = await sequelize.query(
      "PRAGMA table_info('Printers')",
      { type: sequelize.QueryTypes.SELECT, transaction }
    );
    const updatedColumns = updatedTableInfo.map(col => col.name);
    console.log('更新后的Printers表字段:', updatedColumns);
    
    // 为每个系统打印机创建新记录
    let successCount = 0;
    const errors = [];
    
    for (let i = 0; i < systemPrinters.length; i++) {
      const printer = systemPrinters[i];
      try {
        const columnsList = [];
        const valuesList = [];
        const replacements = [];
        
        // 优化IP地址处理逻辑
        // 为了避免唯一性冲突，给每个打印机一个唯一的IP标识
        let ipAddress;
        let port = 9100;
        
        if (printer.portName) {
          // 尝试从端口名称中提取IP地址
          const ipMatch = printer.portName.match(/(\d+\.\d+\.\d+\.\d+)/);
          if (ipMatch && ipMatch[1]) {
            ipAddress = ipMatch[1];
          } else if (printer.portName.toLowerCase().includes('usb')) {
            // USB打印机
            ipAddress = 'USB连接';
          } else if (printer.portName.toLowerCase().includes('com')) {
            // 串口打印机
            ipAddress = '串口连接';
          } else {
            // 其他类型，使用名称作为唯一标识
            ipAddress = `localhost_${printer.name}_${i}`;
          }
        } else {
          // 如果没有端口信息，使用名称作为唯一标识
          ipAddress = `localhost_${printer.name}_${i}`;
        }
        
        // 基础字段
        const fields = {
          name: printer.name,
          ip: ipAddress,
          port: port,
          protocol: 'RAW',
          description: `驱动: ${printer.driverName || '未知'}`,
          isOnline: printer.isReady ? 1 : 0,
          isSystemPrinter: 1, // 标记为系统打印机
          taskCount: 0,
          todayPrintCount: 0,
          failedPrintCount: 0,
          enableColor: 0,
          createdAt: "datetime('now')",
          updatedAt: "datetime('now')"
        };
        
        // 只添加表中存在的字段
        for (const [key, value] of Object.entries(fields)) {
          if (updatedColumns.includes(key)) {
            columnsList.push(key);
            if (key === 'createdAt' || key === 'updatedAt') {
              valuesList.push(value);
            } else {
              valuesList.push('?');
              replacements.push(value);
            }
          }
        }
        
        // 构建动态SQL
        const sql = `
          INSERT INTO Printers (
            ${columnsList.join(', ')}
          ) VALUES (
            ${valuesList.join(', ')}
          )`;
        
        console.log(`插入打印机: ${printer.name}, IP: ${ipAddress}`);
        await sequelize.query(sql, { 
          replacements, 
          transaction 
        });
        
        successCount++;
      } catch (err) {
        console.error(`插入打印机 "${printer.name}" 失败:`, err);
        errors.push({
          name: printer.name,
          error: err.message
        });
      }
    }
    
    // 重新启用外键检查
    await sequelize.query('PRAGMA foreign_keys = ON;', { transaction });
    
    // 提交事务
    await transaction.commit();
    console.log('数据库操作完成');
    
    // 重新查询数据库获取所有打印机
    const updatedPrinters = await Printer.findAll();
    
    console.log(`成功同步 ${successCount} 台打印机到数据库，失败 ${errors.length} 台`);
    res.json({
      success: true,
      message: `成功同步 ${successCount} 台打印机到数据库，失败 ${errors.length} 台`,
      printers: updatedPrinters,
      errors: errors.length > 0 ? errors : undefined
    });
  } catch (error) {
    console.error('同步系统打印机失败:', error);
    
    // 如果事务存在，回滚
    if (transaction) {
      try {
        await transaction.rollback();
        console.log('事务已回滚');
      } catch (rollbackError) {
        console.error('事务回滚失败:', rollbackError);
      }
    }
    
    res.status(500).json({ 
      success: false,
      message: `同步系统打印机失败: ${error.message}`,
      error: error.toString()
    });
  }
});

module.exports = router; 